Annotation of OpenXM_contrib/pari/doc/usersch5.tex, Revision 1.1
1.1 ! maekawa 1: \chapter{Technical Reference Guide for Low-Level Functions}
! 2: \def\B{\kbd{BIL}}
! 3: \def\op{{\it op\/}}
! 4: \def\fun#1#2#3{\noindent{\tt #1 \key{#2}(#3)}:}
! 5:
! 6: In this chapter, we give a description all public low-level functions of the
! 7: PARI system. These essentially include functions for handling all the PARI
! 8: types. Higher level functions, such as arithmetic or transcendental
! 9: functions, are described fully in Chapter~3 of this manual.
! 10:
! 11: Many other undocumented functions can be found throughout the source code.
! 12: These private functions are more efficient than the library functions that
! 13: call them, but much sloppier on argument checking and damage control. Use
! 14: them at your own risk!
! 15:
! 16: \section{Level 0 kernel (operations on unsigned longs)}
! 17:
! 18: \noindent
! 19: For the non-68k versions, we need level 0 operations simulating basic
! 20: operations of the 68020 processor (on which PARI was originally
! 21: implemented). The type \tet{ulong} is defined in the file \kbd{parigen.h} as
! 22: \kbd{unsigned long}. Note that in the prototypes below a \kbd{ulong} is
! 23: sometimes implicitly typecast to \kbd{int} or \kbd{long}.
! 24:
! 25: The global \kbd{ulong} variables \kbd{overflow} (which will contain
! 26: only 0 or 1) and \kbd{hiremainder} used to be declared in the file
! 27: \kbd{pariinl.h}. However, for certain architectures they are no longer
! 28: needed, and/or have been replaced with local variables for efficiency;
! 29: and the `functions' mentioned below are really chunks of assembler code which
! 30: will be inlined at each invocation by the compiler. If you really need to
! 31: use these lowest-level operations directly, make sure you know your way
! 32: through the PARI kernel sources, and understand the architecture dependencies.
! 33:
! 34: To make the following descriptions valid both for 32-bit and 64-bit
! 35: machines, we will set \B\ to be equal to 32 (resp.~64), an abbreviation of
! 36: \kbd{BITS\_IN\_LONG}, which is what is actually used in the source code.
! 37:
! 38: \fun{int}{addll}{int x, int y} adds the ulongs \kbd{x} and \kbd{y},
! 39: returns the lower \B\ bits and puts the carry bit into \kbd{overflow}.
! 40:
! 41: \fun{int}{addllx}{int x, int y} adds \kbd{overflow} to the sum of the
! 42: ulongs \kbd{x} and \kbd{y}, returns the lower \B\ bits and puts the
! 43: carry bit into \kbd{overflow}.
! 44:
! 45: \fun{int}{subll}{int x, int y} subtracts the ulongs \kbd{x} and \kbd{y},
! 46: returns the lower \B\ bits and put the carry (borrow) bit into \kbd{overflow}.
! 47:
! 48: \fun{int}{subllx}{int x, int y} subtracts \kbd{overflow} from the
! 49: difference of the ulongs \kbd{x} and \kbd{y}, returns the lower \B\ bits
! 50: and puts the carry (borrow) bit into \kbd{overflow}.
! 51:
! 52: \fun{int}{shiftl}{ulong x, ulong y} shifts the ulong \kbd{x} left by \kbd{y}
! 53: bits, returns the lower \B\ bits and stores the high-order \B\ bits into
! 54: \kbd{hiremainder}. We must have $1\le\kbd{y}\le\B$. In particular, \kbd{y}
! 55: must be non-zero; the caller is responsible for testing this.
! 56:
! 57: \fun{int}{shiftlr}{ulong x, ulong y} shifts the ulong \kbd{x << \B} right
! 58: by \kbd{y} bits, returns the higher \B\ bits and stores the low-order
! 59: \B\ bits into \kbd{hiremainder}. We must have $1\le\kbd{y}\le\B$. In
! 60: particular, \kbd{y} must be non-zero.
! 61:
! 62: % break ugly ff ligatures in bfffo
! 63: \fun{int}{b{}f{}f{}fo}{ulong x} returns the number of leading zero bits in the
! 64: ulong \kbd{x} (i.e. the number of bit positions by which it would have to be
! 65: shifted left until its leftmost bit first becomes equal to~1, which can be
! 66: between 0 and $\B-1$ for nonzero \kbd{x}). When \kbd{x} is~0, \B\ is returned.
! 67:
! 68: \fun{int}{mulll}{ulong x, ulong y} multiplies the ulong \kbd{x} by the ulong
! 69: \kbd{y}, returns the lower \B\ bits and stores the high-order \B\ bits into
! 70: \kbd{hiremainder}.
! 71:
! 72: \fun{int}{addmul}{ulong x, ulong y} adds \kbd{hiremainder} to the product
! 73: of the ulongs \kbd{x} and \kbd{y}, returns the lower \B\ bits and stores the
! 74: high-order \B\ bits into \kbd{hiremainder}.
! 75:
! 76: \fun{int}{divll}{ulong x, ulong y} returns the Euclidean quotient of
! 77: (\kbd{hiremainder << \B})${}+{}$\kbd{x} and the ulong divisor \kbd{y} and
! 78: stores the remainder into \kbd{hiremainder}. An error occurs if the quotient
! 79: cannot be represented by a ulong, i.e.~if $\kbd{hiremainder}\ge\kbd{y}$
! 80: initially.
! 81:
! 82: \section{Level 1 kernel (operations on longs, integers and reals)}
! 83:
! 84: \noindent
! 85: In this section as elsewhere, \kbd{long} denotes a \B-bit signed C-integer,
! 86: ``integer'' denotes a PARI multiprecise integer (type \typ{INT}), ``real''
! 87: denotes a PARI multiprecise real (type \typ{REAL}). Refer to Chapters
! 88: 1--2 and~4 for general background.
! 89:
! 90: \misctitle{Note:} Many functions consist of an elementary operation,
! 91: immediately followed by an assignment statement. All such functions are
! 92: obtained using macros (see the file \kbd{paricom.h}), hence you can easily
! 93: extend the list. Below, they will be introduced like in the following
! 94: example:
! 95:
! 96: \fun{GEN}{gadd[z]}{GEN x, GEN y[, GEN z]} followed by the explicit
! 97: description of the function
! 98:
! 99: \kbd{GEN \key{gadd}(GEN x, GEN y)}
! 100:
! 101: \noindent which creates its result on the stack, returning a \kbd{GEN} pointer
! 102: to it, and the parts in brackets indicate that there exists also a function
! 103:
! 104: \kbd{void \key{gaddz}(GEN x, GEN y, GEN z)}
! 105:
! 106: \noindent which assigns its result to the pre-existing object
! 107: \kbd{z}, leaving the stack unchanged.
! 108:
! 109: \subsec{Basic unit and subunit handling functions}
! 110:
! 111: \fun{long}{typ}{GEN x} returns the type number of~\kbd{x}. (The header files
! 112: included through \kbd{pari.h} will give you access to the symbolic constants
! 113: \typ{INT} etc., so you should never need to know the actual numerical values.)
! 114:
! 115: \fun{long}{lg}{GEN x} returns the length of~\kbd{x} in \B-bit words.
! 116:
! 117: \fun{long}{lgef}{GEN x} returns the effective length of the polynomial \kbd{x}
! 118: in \B-bit words.
! 119:
! 120: \fun{long}{lgefint}{GEN x} returns the effective length of the integer \kbd{x}
! 121: in \B-bit words.
! 122:
! 123: \fun{long}{signe}{GEN x} returns the sign ($-1$, 0 or 1) of~\kbd{x}. Can be
! 124: used for integers, reals, polynomials and power series (for the last two
! 125: types, only 0 or 1 are possible).
! 126:
! 127: \fun{long}{gsigne}{GEN x} same as \kbd{signe}, but also valid for rational
! 128: numbers (and marginally less efficient for the other types).
! 129:
! 130: \fun{long}{expo}{GEN x} returns the unbiased binary exponent of the real
! 131: number~\kbd{x}.
! 132:
! 133: \fun{long}{gexpo}{GEN x} same as \kbd{expo}, but also valid when \kbd{x}
! 134: is not a real number. When \kbd{x} is an exact~0, this returns
! 135: \hbox{\kbd{-HIGHEXPOBIT}}.
! 136:
! 137: \fun{long}{expi}{GEN x} returns the binary exponent of the real number equal
! 138: to the integer~\kbd{x}. This is a special case of \kbd{gexpo} above, covering
! 139: the case where \kbd{x} is of type~\typ{INT}.
! 140:
! 141: \fun{long}{valp}{GEN x} returns the unbiased 16-bit $p$-adic valuation (for
! 142: a $p$-adic) or $X$-adic valuation (for a power series, taken with respect
! 143: to the main variable) of~\kbd{x}.
! 144:
! 145: \fun{long}{precp}{GEN x} returns the precision of the $p$-adic~\kbd{x}.
! 146:
! 147: \fun{long}{varn}{GEN x} returns the variable number of \kbd{x} (between 0 and
! 148: \kbd{MAXVARN}). Should be used only for polynomials and power series.
! 149:
! 150: \fun{long}{gvar}{(GEN x)} returns the main variable number when any variable
! 151: at all occurs in the composite object~\kbd{x} (the smallest variable number
! 152: which occurs), and \kbd{BIGINT} otherwise.
! 153:
! 154: \fun{void}{settyp}{GEN x, long s} sets the type number of~\kbd{x} to~\kbd{s}.
! 155: This should be used with extreme care since usually the type is set
! 156: otherwise, and the components and further codeword fields (which are left
! 157: unchanged) may not match the PARI conventions for the new type.
! 158:
! 159: \fun{void}{setlg}{GEN x, long s} sets the length of~\kbd{x} to~\kbd{s}. Again
! 160: this should be used with extreme care since usually the length is set
! 161: otherwise, and increasing the length joins previously unrelated memory words
! 162: to the root node of~\kbd{x}. This is, however, an extremely efficient way of
! 163: truncating vectors or polynomials.
! 164:
! 165: \fun{void}{setlgef}{GEN x, long s} sets the effective length of \kbd{x}
! 166: to~\kbd{s}, where \kbd{x} is a polynomial. The number \kbd{s} must be less
! 167: than or equal to the length of~\kbd{x}.
! 168:
! 169: \fun{void}{setlgefint}{GEN x, long s} sets the effective length
! 170: of the integer \kbd{x} to~\kbd{s}. The number \kbd{s} must be less than or
! 171: equal to the length of~\kbd{x}.
! 172:
! 173: \fun{void}{setsigne}{GEN x, long s} sets the sign of~\kbd{x} to~\kbd{s}.
! 174: If \kbd{x} is an integer or real, \kbd{s} must be equal to $-1$, 0 or~1,
! 175: and if \kbd{x} is a polynomial or a power series, \kbd{s} must be equal to
! 176: 0 or~1.
! 177:
! 178: \fun{void}{setexpo}{GEN x, long s} sets the binary exponent of the real
! 179: number~\kbd{x} to \kbd{s}, after adding the appropriate bias. The unbiased
! 180: value \kbd{s} must be a 24-bit signed number.
! 181:
! 182: \fun{void}{setvalp}{GEN x, long s} sets the $p$-adic or $X$-adic valuation
! 183: of~\kbd{x} to~\kbd{s}, if \kbd{x} is a $p$-adic or a power series,
! 184: respectively.
! 185:
! 186: \fun{void}{setprecp}{GEN x, long s} sets the $p$-adic precision of the
! 187: $p$-adic number~\kbd{x} to~\kbd{s}.
! 188:
! 189: \fun{void}{setvarn}{GEN x, long s} sets the variable number of the polynomial
! 190: or power series~\kbd{x} to~\kbd{s} (where $0\le \kbd{s}\le\kbd{MAXVARN}$).
! 191:
! 192:
! 193: \subsec{Memory allocation on the PARI stack}
! 194:
! 195: \fun{GEN}{cgetg}{long n, long t} allocates memory on the PARI stack for
! 196: an object of length \kbd{n} and type~\kbd{t}, and initializes its first
! 197: codeword.
! 198:
! 199: \fun{GEN}{cgeti}{long n} allocates memory on the PARI stack for an
! 200: integer of length~\kbd{n}, and initializes its first codeword. Identical to
! 201: {\tt cgetg(n,\typ{INT})}.
! 202:
! 203: \fun{GEN}{cgetr}{long n} allocates memory on the PARI stack for a real
! 204: of length~\kbd{n}, and initializes its first codeword. Identical to
! 205: {\tt cgetg(n,\typ{REAL})}.
! 206:
! 207: \fun{void}{cgiv}{GEN x} frees object \kbd{x} if it is the last created on the
! 208: PARI stack (otherwise disaster occurs).
! 209:
! 210: \fun{GEN}{gerepile}{long p, long q, GEN x} general garbage collector
! 211: for the PARI stack. See \secref{se:garbage} for a detailed explanation and
! 212: many examples.
! 213:
! 214: \subsec{Assignments, conversions and integer parts}
! 215:
! 216: \fun{void}{mpaff}{GEN x, GEN z} assigns \kbd{x} into~\kbd{z} (where
! 217: \kbd{x} and \kbd{z} are integers or reals).
! 218:
! 219: \fun{void}{affsz}{long s, GEN z} assigns the long \kbd{s} into the integer or
! 220: real~\kbd{z}.
! 221:
! 222: \fun{void}{affsi}{long s, GEN z} assigns the long \kbd{s} into the
! 223: integer~\kbd{z}.
! 224:
! 225: \fun{void}{affsr}{long s, GEN z} assigns the long \kbd{s} into the
! 226: real~\kbd{z}.
! 227:
! 228: \fun{void}{affii}{GEN x, GEN z} assigns the integer \kbd{x} into the
! 229: integer~\kbd{z}.
! 230:
! 231: \fun{void}{affir}{GEN x, GEN z} assigns the integer \kbd{x} into the
! 232: real~\kbd{z}.
! 233:
! 234: \fun{void}{affrs}{GEN x, long s} assigns the real \kbd{x} into the
! 235: long~\kbd{s}\dots not. This is a forbidden assignment in PARI, so an error
! 236: message is issued.
! 237:
! 238: \fun{void}{affri}{GEN x, GEN z} assigns the real \kbd{x} into the
! 239: integer~\kbd{z}\dots no it doesn't. This is a forbidden assignment in PARI,
! 240: so an error message is issued.
! 241:
! 242: \fun{void}{affrr}{GEN x, GEN z} assigns the real \kbd{x} into the real~\kbd{z}.
! 243: \smallskip
! 244:
! 245: \fun{GEN}{stoi}{long s} creates the PARI integer corresponding to the
! 246: long~\kbd{s}.
! 247:
! 248: \fun{long}{itos}{GEN x} converts the PARI integer \kbd{x} to a C long (if
! 249: possible, otherwise an error message is issued).
! 250: \smallskip
! 251:
! 252: \fun{GEN}{mptrunc[z]}{GEN x[, GEN z]} truncates the integer or real~\kbd{x}
! 253: (not the same as the integer part if \kbd{x} is non-integer and negative).
! 254:
! 255: \fun{GEN}{mpent[z]}{GEN x[, GEN z]} true integer part of the integer or
! 256: real~\kbd{x} (i.e.~the \kbd{floor} function).
! 257:
! 258: \subsec{Valuation and shift}
! 259:
! 260: \fun{long}{vals}{long s} 2-adic valuation of the long~\kbd{s}. Returns $-1$
! 261: if \kbd{s} is equal to 0, with no error.
! 262:
! 263: \fun{long}{vali}{GEN x} 2-adic valuation of the integer~\kbd{x}. Returns $-1$
! 264: if \kbd{s} is equal to 0, with no error.
! 265:
! 266: \fun{GEN}{mpshift[z]}{GEN x, long n[, GEN z]} shifts the real or
! 267: integer \kbd{x} by~\kbd{n}. If \kbd{n} is positive, this is a left shift,
! 268: i.e.~multiplication by $2^{\kbd{n}}$. If \kbd{n} is negative, it is a right
! 269: shift by~$-\kbd{n}$, which amounts to the truncation of the quotient of \kbd{x}
! 270: by~$2^{-\kbd{n}}$.
! 271:
! 272: \fun{GEN}{shifts}{long s, long n} converts the long \kbd{s} into a PARI
! 273: integer and shifts the value by~\kbd{n}.
! 274:
! 275: \fun{GEN}{shifti}{GEN x, long n} shifts the integer~\kbd{x} by~\kbd{n}.
! 276:
! 277: \fun{GEN}{shiftr}{GEN x, long n} shifts the real~\kbd{x} by~\kbd{n}.
! 278:
! 279: \subsec{Unary operations}
! 280:
! 281: \noindent
! 282: Let ``\op'' be some unary operation of type \kbd{GEN (*)(GEN)}. The names and
! 283: prototypes of the low-level functions corresponding to \op\ will be as follows.
! 284:
! 285: \fun{GEN}{mp\op}{GEN x} creates the result of \op\ applied to the integer
! 286: or real~\kbd{x}.
! 287:
! 288: \fun{GEN}{\op s}{long s} creates the result of \op\ applied to the
! 289: long~\kbd{s}.
! 290:
! 291: \fun{GEN}{\op i}{GEN x} creates the result of \op\ applied to the
! 292: integer~\kbd{x}.
! 293:
! 294: \fun{GEN}{\op r}{GEN x} creates the result of \op\ applied to the real~\kbd{x}.
! 295:
! 296: \fun{GEN}{mp\op z}{GEN x, GEN z} assigns the result of applying \op\ to the
! 297: integer or real~\kbd{x} into the integer or real \kbd{z}.
! 298:
! 299: \misctitle{Remark:} it has not been considered useful to include the
! 300: functions {\tt void \op sz(long,GEN)}, {\tt void \op iz(GEN,GEN)} and
! 301: {\tt void \op rz(GEN, GEN)}.
! 302: \smallskip
! 303:
! 304: \noindent The above prototype schemes apply to the following operators:
! 305:
! 306: \op=\key{neg}: negation ($-$\kbd{x}). The result is of the same type
! 307: as~\kbd{x}.
! 308:
! 309: \op=\key{abs}: absolute value ($|\kbd{x}|$). The result is of the same type
! 310: as~\kbd{x}.
! 311:
! 312: \noindent In addition, there exist the following special unary functions with
! 313: assignment:
! 314:
! 315: \fun{void}{mpinvz}{GEN x, GEN z} assigns the inverse of the integer or
! 316: real \kbd{x} into the real~\kbd{z}. The inverse is computed as a quotient
! 317: of real numbers, not as a Euclidean division.
! 318:
! 319: \fun{void}{mpinvsr}{long s, GEN z} assigns the inverse of the long \kbd{s}
! 320: into the real~\kbd{z}.
! 321:
! 322: \fun{void}{mpinvir}{GEN x, GEN z} assigns the inverse of the integer \kbd{x}
! 323: into the real~\kbd{z}.
! 324:
! 325: \fun{void}{mpinvrr}{GEN x, GEN z} assigns the inverse of the real \kbd{x} into
! 326: the real~\kbd{z}.
! 327:
! 328: \subsec{Comparison operators}
! 329:
! 330: \fun{long}{mpcmp}{GEN x, GEN y} compares the integer or real \kbd{x} to the
! 331: integer or real~\kbd{y}. The result is the sign of $\kbd{x}-\kbd{y}$.
! 332:
! 333: \fun{long}{cmpss}{long s, long t} returns the sign of $\kbd{s}-\kbd{t}$.
! 334:
! 335: \fun{long}{cmpsi}{long s, GEN x} compares the long \kbd{s} to the
! 336: integer~\kbd{x}.
! 337:
! 338: \fun{long}{cmpsr}{long s, GEN x} compares the long \kbd{s} to the real~\kbd{x}.
! 339:
! 340: \fun{long}{cmpis}{GEN x, long s} compares the integer \kbd{x} to the
! 341: long~\kbd{s}.
! 342:
! 343: \fun{long}{cmpii}{GEN x, GEN y} compares the integer \kbd{x} to the
! 344: integer~\kbd{y}.
! 345:
! 346: \fun{long}{cmpir}{GEN x, GEN y} compares the integer \kbd{x} to the
! 347: real~\kbd{y}.
! 348:
! 349: \fun{long}{cmprs}{GEN x, long s} compares the real \kbd{x} to the
! 350: long~\kbd{s}.
! 351:
! 352: \fun{long}{cmpri}{GEN x, GEN y} compares the real \kbd{x} to the
! 353: integer~\kbd{y}.
! 354:
! 355: \fun{long}{cmprr}{GEN x, GEN y} compares the real \kbd{x} to the real~\kbd{y}.
! 356:
! 357: \subsec{Binary operations}
! 358:
! 359: \noindent
! 360: Let ``\op'' be some operation of type \kbd{GEN (*)(GEN,GEN)}. The names and
! 361: prototypes of the low-level functions corresponding to \op\ will be as follows.
! 362: In this section, the \kbd{z} argument in the \kbd{z}-functions must be of type
! 363: \typ{INT} or~\typ{REAL}.
! 364:
! 365: \fun{GEN}{mp\op[z]}{GEN x, GEN y[, GEN z]} applies \op\ to
! 366: the integer-or-reals \kbd{x} and~\kbd{y}.
! 367:
! 368: \fun{GEN}{\op ss[z]}{long s, long t[, GEN z]} applies \op\ to the longs
! 369: \kbd{s} and~\kbd{t}.
! 370:
! 371: \fun{GEN}{\op si[z]}{long s, GEN x[, GEN z]} applies \op\ to the long \kbd{s}
! 372: and the integer~\kbd{x}.
! 373:
! 374: \fun{GEN}{\op sr[z]}{long s, GEN x[, GEN z]} applies \op\ to the long \kbd{s}
! 375: and the real~\kbd{x}.
! 376:
! 377: \fun{GEN}{\op is[z]}{GEN x, long s[, GEN z]} applies \op\ to the
! 378: integer \kbd{x} and the long~\kbd{s}.
! 379:
! 380: \fun{GEN}{\op ii[z]}{GEN x, GEN y[, GEN z]} applies \op\ to the
! 381: integers \kbd{x} and~\kbd{y}.
! 382:
! 383: \fun{GEN}{\op ir[z]}{GEN x, GEN y[, GEN z]} applies \op\ to the
! 384: integer \kbd{x} and the real~\kbd{y}.
! 385:
! 386: \fun{GEN}{\op rs[z]}{GEN x, long s[, GEN z]} applies \op\ to the real \kbd{x}
! 387: and the long~\kbd{s}.
! 388:
! 389: \fun{GEN}{\op ri[z]}{GEN x, GEN y[, GEN z]} applies \op\ to the real \kbd{x}
! 390: and the integer~\kbd{y}.
! 391:
! 392: \fun{GEN}{\op rr[z]}{GEN x, GEN y[, GEN z]} applies \op\ to the reals \kbd{x}
! 393: and~\kbd{y}.
! 394: \smallskip
! 395: \noindent Each of the above can be used with the following operators.
! 396:
! 397: \op=\key{add}: addition (\kbd{x + y}). The result is real unless both \kbd{x}
! 398: and \kbd{y} are integers (or longs).
! 399:
! 400: \op=\key{sub}: subtraction (\kbd{x - y}). The result is real unless both
! 401: \kbd{x} and \kbd{y} are integers (or longs).
! 402:
! 403: \op=\key{mul}: multiplication (\kbd{x * y}). The result is real unless both
! 404: \kbd{x} and \kbd{y} are integers (or longs), OR if \kbd{x} or \kbd{y} is the
! 405: integer or long zero.
! 406:
! 407: \op=\key{div}: division (\kbd{x / y}). In the case where \kbd{x} and \kbd{y}
! 408: are both integers or longs, the result is the Euclidean quotient, where the
! 409: remainder has the same sign as the dividend~\kbd{x}. If one of \kbd{x} or
! 410: \kbd{y} is real, the result is real unless \kbd{x} is the integer or long
! 411: zero. A division-by-zero error occurs if \kbd{y} is equal to zero.
! 412:
! 413: \op=\key{res}: remainder (``\kbd{x \% y}''). This operation is defined only
! 414: when \kbd{x} and \kbd{y} are longs or integers. The result is the Euclidean
! 415: remainder corresponding to \kbd{div},~i.e. its sign is that of the
! 416: dividend~\kbd{x}. The result is always an integer.
! 417:
! 418: \op=\key{mod}: remainder (\kbd{x \% y}). This operation is defined only when
! 419: \kbd{x} and \kbd{y} are longs or integers. The result is the true Euclidean
! 420: remainder, i.e.~non-negative and less than the absolute value of~\kbd{y}.
! 421:
! 422: \subsec{Division with remainder}: the following functions return two objects,
! 423: unless specifically asked for only one of them~--- a quotient and a remainder.
! 424: The remainder will be created on the stack, and a \kbd{GEN} pointer to this
! 425: object will be returned through the variable whose address is passed as the
! 426: \kbd{r} argument.
! 427:
! 428: \fun{GEN}{dvmdss}{long s, long t, GEN *r} creates the Euclidean
! 429: quotient and remainder of the longs \kbd{s} and~\kbd{t}. If \kbd{r} is not
! 430: \kbd{NULL} or \kbd{ONLY\_REM}, this puts the remainder into \kbd{*r},
! 431: and returns the quotient. If \kbd{r} is equal to \kbd{NULL}, only the
! 432: quotient is returned. If \kbd{r} is equal to \kbd{ONLY\_REM}, the remainder
! 433: is returned instead of the quotient. In the generic case, the remainder is
! 434: created after the quotient and can be disposed of individually with a
! 435: \kbd{cgiv(r)}. The remainder is always of the sign of the dividend~\kbd{s}.
! 436:
! 437: \fun{GEN}{dvmdsi}{long s, GEN x, GEN *r} creates the Euclidean
! 438: quotient and remainder of the long \kbd{s} by the integer~\kbd{x}.
! 439: Obeys the same conventions with respect to~\kbd{r}.
! 440:
! 441: \fun{GEN}{dvmdis}{GEN x, long s, GEN *r} create the Euclidean
! 442: quotient and remainder of the integer x by the long~s.
! 443:
! 444: \fun{GEN}{dvmdii}{GEN x, GEN y, GEN *r} returns the Euclidean quotient
! 445: of the integer \kbd{x} by the integer \kbd{y} and puts the remainder
! 446: into~\kbd{*r}. If \kbd{r} is equal to \kbd{NULL}, the remainder is not
! 447: created, and if \kbd{r} is equal to \kbd{ONLY\_REM}, only the remainder
! 448: is created and returned. In the generic case, the remainder is created
! 449: after the quotient and can be disposed of individually with a \kbd{cgiv(r)}.
! 450: The remainder is always of the sign of the dividend~\kbd{x}.
! 451:
! 452: \fun{GEN}{truedvmdii}{GEN x, GEN y, GEN *r}, as \kbd{dvmdii} but with a
! 453: non-negative remainder.
! 454:
! 455: \fun{void}{mpdvmdz}{GEN x, GEN y, GEN z, GEN *r} assigns the Euclidean
! 456: quotient of the integers \kbd{x} and \kbd{y} into the integer or real~\kbd{z},
! 457: putting the remainder into~\kbd{*r} (unless \kbd{r} is equal to \kbd{NULL} or
! 458: \kbd{ONLY\_REM} as above).
! 459:
! 460: \fun{void}{dvmdssz}{long s, long t, GEN z, GEN *r} assigns the Euclidean
! 461: quotient of the longs \kbd{s} and \kbd{t} into the integer or real~\kbd{z},
! 462: putting the remainder into~\kbd{*r} (unless \kbd{r} is equal to \kbd{NULL} or
! 463: \kbd{ONLY\_REM} as above).
! 464:
! 465: \fun{void}{dvmdsiz}{long s, GEN x, GEN z, GEN *r} assigns the Euclidean
! 466: quotient of the long \kbd{s} and the integer \kbd{x} into the integer or
! 467: real~\kbd{z}, putting the remainder into \kbd{*r} (unless \kbd{r} is equal
! 468: to \kbd{NULL} or \kbd{ONLY\_REM} as above).
! 469:
! 470: \fun{void}{dvmdisz}{GEN x, long s, GEN z, GEN *r} assigns the Euclidean
! 471: quotient of the integer \kbd{x} and the long \kbd{s} into the integer or
! 472: real~\kbd{z}, putting the remainder into~\kbd{*r} (unless \kbd{r} is equal
! 473: to \kbd{NULL} or \kbd{ONLY\_REM} as above).
! 474:
! 475: \fun{void}{dvmdiiz}{GEN x, GEN y, GEN z, GEN *r} assigns the Euclidean
! 476: quotient of the integers \kbd{x} and \kbd{y} into the integer or real~\kbd{z},
! 477: putting the address of the remainder into~\kbd{*r} (unless \kbd{r} is equal
! 478: to \kbd{NULL} or \kbd{ONLY\_REM} as above).
! 479:
! 480: \subsec{Miscellaneous functions}
! 481:
! 482: \fun{void}{addsii}{long s, GEN x, GEN z} assigns the sum of the long \kbd{s}
! 483: and the integer \kbd{x} into the integer~\kbd{z} (essentially identical to
! 484: \kbd{addsiz} except that \kbd{z} is specifically an integer).
! 485:
! 486: \fun{long}{divise}{GEN x, GEN y} if the integer \kbd{y} divides the
! 487: integer~\kbd{x}, returns 1 (true), otherwise returns 0 (false).
! 488:
! 489: \fun{long}{divisii}{GEN x, long s, GEN z} assigns the Euclidean quotient of
! 490: the integer \kbd{x} and the long \kbd{s} into the integer \kbd{z}, and returns
! 491: the remainder as a long.
! 492:
! 493: \fun{long}{mpdivis}{GEN x, GEN y, GEN z} if the integer \kbd{y} divides the
! 494: integer~\kbd{x}, assigns the quotient to the integer~\kbd{z} and returns
! 495: 1 (true), otherwise returns 0 (false).
! 496:
! 497: \fun{void}{mulsii}{long s, GEN x, GEN z} assigns the product of the long
! 498: \kbd{s} and the integer \kbd{x} into the integer~\kbd{z} (essentially
! 499: dentical to \kbd{mulsiz} except that \kbd{z} is specifically an integer).
! 500:
! 501: \section{Level 2 kernel (operations on general PARI objects)}
! 502:
! 503: \noindent The functions available to handle subunits are the following.
! 504:
! 505: \fun{GEN}{compo}{GEN x, long n} creates a copy of the \kbd{n}-th true
! 506: component (i.e.\ not counting the codewords) of the object~\kbd{x}.
! 507:
! 508: \fun{GEN}{truecoeff}{GEN x, long n} creates a copy of the coefficient of
! 509: degree~\kbd{n} of~\kbd{x} if \kbd{x} is a scalar, polynomial or power series,
! 510: and otherwise of the \kbd{n}-th component of~\kbd{x}.
! 511:
! 512: \noindent % borderline case -- looks better like this [GN]
! 513: The remaining two are macros, NOT functions (see \secref{se:typecast} for a
! 514: detailed explanation):
! 515:
! 516: \fun{long}{coeff}{GEN x, long i, long j} applied to a matrix \kbd{x} (type
! 517: \typ{MAT}), this gives the address of the coefficient at row \kbd{i} and
! 518: column~\kbd{j} of~\kbd{x}.
! 519:
! 520: \fun{long}{mael$n$}{GEN x, long $a_1$, ..., long $a_n$} stands for
! 521: \kbd{x[$a_1$][$a_2$]...[$a_n$]}, where $2\le n \le 5$, with all the
! 522: necessary typecasts.
! 523:
! 524: \subsec{Copying and conversion}
! 525:
! 526: \fun{GEN}{cgetp}{GEN x} creates space sufficient to hold the $p$-adic~\kbd{x},
! 527: and sets the prime $p$ and the $p$-adic precision to those of~\kbd{x}, but
! 528: does not copy (the $p$-adic unit or zero representative and the modulus
! 529: of)~\kbd{x}.
! 530:
! 531: \fun{GEN}{gcopy}{GEN x} creates a new copy of the object~\kbd{x} on the PARI
! 532: stack. For permanent subobjects, only the pointer is copied.
! 533:
! 534: \fun{GEN}{forcecopy}{GEN x} same as \key{copy} except that even permanent
! 535: subobjects are copied onto the stack.
! 536:
! 537: \fun{long}{taille}{GEN x} returns the total number of \B-bit words occupied
! 538: by the tree representing~\kbd{x}.
! 539:
! 540: \fun{GEN}{gclone}{GEN x} creates a new permanent copy of the object \kbd{x}
! 541: on the heap.
! 542:
! 543: \fun{GEN}{greffe}{GEN x, long l, int use\_stack} applied to a
! 544: polynomial~\kbd{x} (type \typ{POL}), creates a power series (type \typ{SER})
! 545: of length~\kbd{l} starting with~\kbd{x}, but without actually copying the
! 546: coefficients, just the pointers. If \kbd{use\_stack} is zero, this is created
! 547: through malloc, and must be freed after use. Intended for internal use only.
! 548:
! 549: \fun{double}{rtodbl}{GEN x} applied to a real~\kbd{x} (type \typ{REAL}),
! 550: converts \kbd{x} into a C double if possible.
! 551:
! 552: \fun{GEN}{dbltor}{double x} converts the C double \kbd{x} into a PARI real.
! 553:
! 554: \fun{double}{gtodouble}{GEN x} if \kbd{x} is a real number (but not
! 555: necessarily of type \typ{REAL}), converts \kbd{x} into a C double if possible.
! 556:
! 557: \fun{long}{gtolong}{GEN x} if \kbd{x} is an integer (not a C long,
! 558: but not necessarily of type \typ{INT}), converts \kbd{x} into a C long
! 559: if possible.
! 560:
! 561: \fun{GEN}{gtopoly}{GEN x, long v} converts or truncates the object~\kbd{x}
! 562: into a polynomial with main variable number~\kbd{v}. A common application
! 563: would be the conversion of coefficient vectors.
! 564:
! 565: \fun{GEN}{gtopolyrev}{GEN x, long v} converts or truncates the object~\kbd{x}
! 566: into a polynomial with main variable number~\kbd{v}, but vectors are converted
! 567: in reverse order.
! 568:
! 569: \fun{GEN}{gtoser}{GEN x, long v} converts the object~\kbd{x} into a power
! 570: series with main variable number~\kbd{v}.
! 571:
! 572: \fun{GEN}{gtovec}{GEN x} converts the object~\kbd{x} into a (row) vector.
! 573:
! 574: \fun{GEN}{co8}{GEN x, long l} applied to a quadratic number~\kbd{x}
! 575: (type \typ{QUAD}), converts \kbd{x} into a real or complex number
! 576: depending on the sign of the discriminant of~\kbd{x}, to precision
! 577: \hbox{\kbd{l} \B-bit} words.% absolutely forbid line brk at hyphen here [GN]
! 578:
! 579: \fun{GEN}{gcvtop}{GEN x, GEN p, long l} converts \kbd{x} into a \kbd{p}-adic
! 580: number of precision~\kbd{l}.
! 581:
! 582: \fun{GEN}{gmodulcp}{GEN x, GEN y} creates the object \kbd{\key{Mod}(x,y)}
! 583: on the PARI stack, where \kbd{x} and \kbd{y} are either both integers, and
! 584: the result is an integermod (type \typ{INTMOD}), or \kbd{x} is a scalar or
! 585: a polynomial and \kbd{y} a polynomial, and the result is a polymod
! 586: (type \typ{POLMOD}).
! 587:
! 588: \fun{GEN}{gmodulgs}{GEN x, long y} same as \key{gmodulcp} except \kbd{y} is a
! 589: \kbd{long}.
! 590:
! 591: \fun{GEN}{gmodulss}{long x, long y} same as \key{gmodulcp} except both \kbd{x}
! 592: and \kbd{y} are \kbd{long}s.
! 593:
! 594: \fun{GEN}{gmodulo}{GEN x, GEN y} same as \key{gmodulcp} except that the
! 595: modulus \kbd{y} is copied onto the heap and not onto the PARI stack.
! 596:
! 597: \fun{long}{gexpo}{GEN x} returns the binary exponent of \kbd{x} or the maximal
! 598: binary exponent of the coefficients of~\kbd{x}. Returns
! 599: \hbox{\kbd{-HIGHEXPOBIT}} if \kbd{x} has no components or is an exact zero.
! 600:
! 601: \fun{long}{gsize}{GEN x} returns 0 if \kbd{x} is exactly~0. Otherwise,
! 602: returns \kbd{\key{gexpo}(x)} multiplied by $\log_{10}(2)$. This gives a
! 603: crude estimate for the maximal number of decimal digits of the components
! 604: of~\kbd{x}.
! 605:
! 606: \fun{long}{gsigne}{GEN x} returns the sign of~\kbd{x} ($-1$, 0 or 1) when
! 607: \kbd{x} is an integer, real or (irreducible or reducible) fraction. Raises
! 608: an error for all other types.
! 609:
! 610: \fun{long}{gvar}{GEN x} returns the main variable of~\kbd{x}. If no component
! 611: of~\kbd{x} is a polynomial or power series, this returns \kbd{BIGINT}.
! 612:
! 613: \fun{int}{precision}{GEN x} If \kbd{x} is of type \typ{REAL}, returns the
! 614: precision of~\kbd{x} (the length of \kbd{x} in \B-bit words if \kbd{x} is
! 615: not zero, and a reasonable quantity obtained from the exponent of \kbd{x}
! 616: if \kbd{x} is numerically equal to zero). If \kbd{x} is of type \typ{COMPLEX},
! 617: returns the minimum of the precisions of the real and imaginary part.
! 618: Otherwise, returns~0 (which stands in fact for infinite precision).
! 619:
! 620: \subsec{Comparison operators and valuations}
! 621:
! 622: \fun{int}{gcmp0}{GEN x} returns 1 (true) if \kbd{x} is equal to~0, 0~(false)
! 623: otherwise.
! 624:
! 625: \fun{int}{isexactzero}{GEN x} returns 1 (true) if \kbd{x} is exactly equal
! 626: to~0, 0~(false) otherwise. Note that many PARI functions will return a
! 627: pointer to \key{gzero} when they are aware that the result they return is
! 628: an exact zero, so it is almost always faster to test for pointer equality
! 629: first, and call \key{isexactzero} (or \key{gcmp0}) only when the first
! 630: test fails.
! 631:
! 632: \fun{int}{gcmp1}{GEN x} returns 1 (true) if \kbd{x} is equal to~1, 0~(false)
! 633: otherwise.
! 634:
! 635: \fun{int}{gcmp\_1}{GEN x} returns 1 (true) if \kbd{x} is equal to~$-1$,
! 636: 0~(false) otherwise.
! 637:
! 638: \fun{long}{gcmp}{GEN x, GEN y} comparison of \kbd{x} with \kbd{y} (returns
! 639: the sign of $\kbd{x}-\kbd{y}$).
! 640:
! 641: \fun{long}{gcmpsg}{long s, GEN x} comparison of the long \kbd{s} with~\kbd{x}.
! 642:
! 643: \fun{long}{gcmpgs}{GEN x, long s} comparison of \kbd{x} with the long~\kbd{s}.
! 644:
! 645: \fun{long}{lexcmp}{GEN x, GEN y} comparison of \kbd{x} with \kbd{y} for the
! 646: lexicographic ordering.
! 647:
! 648: \fun{long}{gegal}{GEN x, GEN y} returns 1 (true) if \kbd{x} is equal
! 649: to~\kbd{y}, 0~otherwise.
! 650:
! 651: \fun{long}{gegalsg}{long s, GEN x} returns 1 (true) if the long \kbd{s} is
! 652: equal to~\kbd{x}, 0~otherwise.
! 653:
! 654: \fun{long}{gegalgs}{GEN x, long s} returns 1 (true) if \kbd{x} is equal to
! 655: the long~\kbd{s}, 0~otherwise.
! 656:
! 657: \fun{long}{iscomplex}{GEN x} returns 1 (true) if \kbd{x} is a complex number
! 658: (of component types embeddable into the reals) but is not itself real, 0~if
! 659: \kbd{x} is a real (not necessarily of type \typ{REAL}), or raises an error
! 660: if \kbd{x} is not embeddable into the complex numbers.
! 661:
! 662: \fun{long}{ismonome}{GEN x} returns 1 (true) if \kbd{x} is a non-zero monomial
! 663: in its main variable, 0~otherwise.
! 664:
! 665: \fun{long}{ggval}{GEN x, GEN p} returns the greatest exponent~$e$ such that
! 666: $\kbd{p}^e$ divides~\kbd{x}, when this makes sense.
! 667:
! 668: \fun{long}{gval}{GEN x, long v} returns the highest power of the variable
! 669: number \kbd{v} dividing the polynomial~\kbd{x}.
! 670:
! 671: \fun{int}{pvaluation}{GEN x, GEN p, GEN *r} applied to non-zero integers
! 672: \kbd{x} and~\kbd{p}, returns the highest exponent $e$ such that
! 673: $\kbd{p}^{e}$ divides~\kbd{x}, creates the quotient $\kbd{x}/\kbd{p}^{e}$
! 674: and returns its address in~\kbd{*r}.
! 675: In particular, if \kbd{p} is a prime, this returns the valuation at \kbd{p}
! 676: of~\kbd{x}, and \kbd{*r} will obtain the prime-to-\kbd{p} part of~\kbd{x}.
! 677:
! 678: \subsec{Assignment statements}
! 679:
! 680: \fun{void}{gaffsg}{long s, GEN x} assigns the long \kbd{s} into the
! 681: object~\kbd{x}.
! 682:
! 683: \fun{void}{gaffect}{GEN x, GEN y} assigns the object \kbd{x} into the
! 684: object~\kbd{y}.
! 685:
! 686: \subsec{Unary operators}
! 687:
! 688: \fun{GEN}{gneg[\key{z}]}{GEN x[, GEN z]} yields $-\kbd{x}$.
! 689:
! 690: \fun{GEN}{gabs[\key{z}]}{GEN x[, GEN z]} yields $|\kbd{x}|$.
! 691:
! 692: \fun{GEN}{gsqr}{GEN x} creates the square of~\kbd{x}.
! 693:
! 694: \fun{GEN}{ginv}{GEN x} creates the inverse of~\kbd{x}.
! 695:
! 696: \fun{GEN}{gfloor}{GEN x} creates the floor of~\kbd{x}, i.e.\ the (true)
! 697: integral part.
! 698:
! 699: \fun{GEN}{gfrac}{GEN x} creates the fractional part of~\kbd{x}, i.e.\ \kbd{x}
! 700: minus the floor of~\kbd{x}.
! 701:
! 702: \fun{GEN}{gceil}{GEN x} creates the ceiling of~\kbd{x}.
! 703:
! 704: \fun{GEN}{ground}{GEN x} rounds the components of \kbd{x} to the nearest
! 705: integers. Exact half-integers are rounded towards~$+\infty$.
! 706:
! 707: \fun{GEN}{grndtoi}{GEN x, long *e} same as \key{round}, but in addition puts
! 708: minus the number of significant binary bits left after rounding into~\kbd{*e}.
! 709: If \kbd{*e} is positive, all significant bits have been lost. This kind of
! 710: situation raises an error message in \key{ground} but not in \key{grndtoi}.
! 711:
! 712: \fun{GEN}{gtrunc}{GEN x} truncates~\kbd{x}. This is the (false) integer part
! 713: if \kbd{x} is an integer (i.e.~the unique integer closest to \kbd{x} among
! 714: those between 0 and~\kbd{x}). If \kbd{x} is a series, it will be truncated
! 715: to a polynomial; if \kbd{x} is a rational function, this takes the
! 716: polynomial part.
! 717:
! 718: \fun{GEN}{gcvtoi}{GEN x, long *e} same as \key{grndtoi} except that
! 719: rounding is replaced by truncation.
! 720:
! 721: \fun{GEN}{gred[z]}{GEN x[, GEN z]} reduces \kbd{x} to lowest terms if \kbd{x}
! 722: is a fraction or rational function (types \typ{FRAC}, \typ{FRACN},
! 723: \typ{RFRAC} and \typ{RFRACN}), otherwise creates a copy of~\kbd{x}.
! 724:
! 725: \fun{GEN}{content}{GEN x} creates the GCD of all the components of~\kbd{x}.
! 726:
! 727: \fun{GEN}{normalize}{GEN x} applied to an unnormalized power series~\kbd{x}
! 728: (i.e.~type \typ{SER} with all coefficients correctly set except that \kbd{x[2]}
! 729: might be zero), normalizes \kbd{x} correctly in place. Returns~\kbd{x}.
! 730: For internal use.
! 731:
! 732: \fun{GEN}{normalizepol}{GEN x} applied to an unnormalized polynomial~\kbd{x}
! 733: (i.e.~type \typ{POL} with all coefficients correctly set except that \kbd{x[2]}
! 734: might be zero), normalizes \kbd{x} correctly in place and returns~\kbd{x}.
! 735: For internal use.
! 736:
! 737: \subsec{Binary operators}
! 738:
! 739: \fun{GEN}{gmax[z]}{GEN x, GEN y[, GEN z]} yields the maximum of the objects
! 740: \kbd{x} and~\kbd{y} if they can be compared.
! 741:
! 742: \fun{GEN}{gmaxsg[z]}{long s, GEN x[, GEN z]} yields the maximum of the long
! 743: \kbd{s} and the object~\kbd{x}.
! 744:
! 745: \fun{GEN}{gmaxgs[z]}{GEN x, long s[, GEN z]} yields the maximum of the object
! 746: \kbd{x} and the long~\kbd{s}.
! 747:
! 748: \fun{GEN}{gmin[z]}{GEN x, GEN y[, GEN z]} yields the minimum of the objects
! 749: \kbd{x} and~\kbd{y} if they can be compared.
! 750:
! 751: \fun{GEN}{gminsg[z]}{long s, GEN x[, GEN z]} yields the minimum of the long
! 752: \kbd{s} and the object~\kbd{x}.
! 753:
! 754: \fun{GEN}{gmings[z]}{GEN x, long s[, GEN z]} yields the minimum of the object
! 755: \kbd{x} and the long~\kbd{s}.
! 756:
! 757: \fun{GEN}{gadd[z]}{GEN x, GEN y[, GEN z]} yields the sum of the objects \kbd{x}
! 758: and~\kbd{y}.
! 759:
! 760: \fun{GEN}{gaddsg[z]}{long s, GEN x[, GEN z]} yields the sum of the long \kbd{s}
! 761: and the object~\kbd{x}.
! 762:
! 763: \fun{GEN}{gaddgs[z]}{GEN x, long s[, GEN z]} yields the sum of the object
! 764: \kbd{x} and the long~\kbd{s}.
! 765:
! 766: \fun{GEN}{gsub[z]}{GEN x, GEN y[, GEN z]} yields the difference of the objects
! 767: \kbd{x} and~\kbd{y}.
! 768:
! 769: \fun{GEN}{gsubgs[z]}{GEN x, long s[, GEN z]} yields the difference of the
! 770: object \kbd{x} and the long~\kbd{s}.
! 771:
! 772: \fun{GEN}{gsubsg[z]}{long s, GEN x[, GEN z]} yields the difference of the
! 773: long \kbd{s} and the object~\kbd{x}.
! 774:
! 775: \fun{GEN}{gmul[z]}{GEN x, GEN y[, GEN z]} yields the product of the objects
! 776: \kbd{x} and~\kbd{y}.
! 777:
! 778: \fun{GEN}{gmulsg[z]}{long s, GEN x[, GEN z]} yields the product of the long
! 779: \kbd{s} with the object~\kbd{x}.
! 780:
! 781: \fun{GEN}{gmulgs[z]}{GEN x, long s[, GEN z]} yields the product of the object
! 782: \kbd{x} with the long~\kbd{s}.
! 783:
! 784: \fun{GEN}{gshift[z]}{GEN x, long n[, GEN z]} yields the result of shifting
! 785: (the components of) \kbd{x} left by \kbd{n} (if \kbd{n} is non-negative)
! 786: or right by $-\kbd{n}$ (if \kbd{n} is negative).
! 787: Applies only to integers, reals and vectors/matrices of such. For other
! 788: types, it is simply multiplication by~$2^{\kbd{n}}$.
! 789:
! 790: \fun{GEN}{gmul2n[z]}{GEN x, long n[, GEN z]} yields the product of \kbd{x}
! 791: and~$2^{\kbd{n}}$. This is different from \kbd{gshift} when \kbd{n} is negative
! 792: and \kbd{x} is of type \typ{INT}: \key{gshift} truncates, while \key{gmul2n}
! 793: creates a fraction if necessary.
! 794:
! 795: \fun{GEN}{gdiv[z]}{GEN x, GEN y[, GEN z]} yields the quotient of the objects
! 796: \kbd{x} and~\kbd{y}.
! 797:
! 798: \fun{GEN}{gdivgs[z]}{GEN x, long s[, GEN z]} yields the quotient of the object
! 799: \kbd{x} and the long~\kbd{s}.
! 800:
! 801: \fun{GEN}{gdivsg[z]}{long s, GEN x[, GEN z]} yields the quotient of the long
! 802: \kbd{s} and the object~\kbd{x}.
! 803:
! 804: \fun{GEN}{gdivent[z]}{GEN x, GEN y[, GEN z]} yields the true Euclidean
! 805: quotient of \kbd{x} and the integer or polynomial~\kbd{y}.
! 806:
! 807: \fun{GEN}{gdiventsg[z]}{long s, GEN x[, GEN z]} yields the true Euclidean
! 808: quotient of the long \kbd{s} by the integer~\kbd{x}.
! 809:
! 810: \fun{GEN}{gdiventgs[z]}{GEN x, long s[, GEN z]} yields the true Euclidean
! 811: quotient of the integer \kbd{x} by the long~\kbd{s}.
! 812:
! 813: \fun{GEN}{gdiventres}{GEN x, GEN y} creates a 2-component vertical
! 814: vector whose components are the true Euclidean quotient and remainder
! 815: of \kbd{x} and~\kbd{y}.
! 816:
! 817: \fun{GEN}{gdivmod}{GEN x, GEN y, GEN *r} If \kbd{r} is not equal to
! 818: \kbd{NULL} or \kbd{ONLY\_REM}, creates the (false) Euclidean quotient of
! 819: \kbd{x} and~\kbd{y}, and puts (the address of) the remainder into~\kbd{*r}.
! 820: If \kbd{r} is equal to \kbd{NULL}, do not create the remainder, and if
! 821: \kbd{r} is equal to \kbd{ONLY\_REM}, create and output only the remainder.
! 822: The remainder is created after the quotient and can be disposed of
! 823: individually with a \kbd{cgiv(r)}.
! 824:
! 825: \fun{GEN}{poldivres}{GEN x, GEN y, GEN *r} same as \key{gdivmod} but
! 826: specifically for polynomials \kbd{x} and~\kbd{y}.
! 827:
! 828: \fun{GEN}{gdeuc}{GEN x, GEN y} creates the Euclidean quotient of the
! 829: polynomials \kbd{x} and~\kbd{y}.
! 830:
! 831: \fun{GEN}{gdivround}{GEN x, GEN y} if \kbd{x} and \kbd{y} are integers,
! 832: returns the quotient $\kbd{x}/\kbd{y}$ of \kbd{x} and~\kbd{y}, rounded to
! 833: the nearest integer. If $\kbd{x}/\kbd{y}$ falls exactly halfway between
! 834: two consecutive integers, then it is rounded towards~$+\infty$ (as for
! 835: \key{round}). If \kbd{x} and \kbd{y} are not both integers, the result
! 836: is the same as that of \key{gdivent}.
! 837:
! 838: \fun{GEN}{gmod[z]}{GEN x, GEN y[, GEN z]} yields the true remainder of \kbd{x}
! 839: modulo the integer or polynomial~\kbd{y}.
! 840:
! 841: \fun{GEN}{gmodsg[z]}{long s, GEN x[, GEN z]} yields the true remainder of the
! 842: long \kbd{s} modulo the integer~\kbd{x}.
! 843:
! 844: \fun{GEN}{gmodgs[z]}{GEN x, long s[, GEN z]} yields the true remainder of the
! 845: integer \kbd{x} modulo the long~\kbd{s}.
! 846:
! 847: \fun{GEN}{gres}{GEN x, GEN y} creates the Euclidean remainder of the
! 848: polynomial \kbd{x} divided by the polynomial~\kbd{y}.
! 849:
! 850: \fun{GEN}{ginvmod}{GEN x, GEN y} creates the inverse of \kbd{x} modulo \kbd{y}
! 851: when it exists.
! 852:
! 853: \fun{GEN}{gpow}{GEN x, GEN y, long l} creates $\kbd{x}^{\kbd{y}}$. The
! 854: precision \kbd{l} is taken into account only if \kbd{y} is not an integer
! 855: and \kbd{x} is an exact object. If \kbd{y} is an integer, binary powering
! 856: is done. Otherwise, the result is $\exp(\kbd{y}*\log(\kbd{x}))$ computed
! 857: to precision~\kbd{l}.
! 858:
! 859: \fun{GEN}{ggcd}{GEN x, GEN y} creates the GCD of \kbd{x} and~\kbd{y}.
! 860:
! 861: \fun{GEN}{glcm}{GEN x, GEN y} creates the LCM of \kbd{x} and~\kbd{y}.
! 862:
! 863: \fun{GEN}{subres}{GEN x, GEN y} creates the resultant of the polynomials
! 864: \kbd{x} and~\kbd{y} computed using the subresultant algorithm.
! 865:
! 866: \fun{GEN}{gpowgs}{GEN x, long n} creates $\kbd{x}^{\kbd{n}}$ using
! 867: binary powering.
! 868:
! 869: \fun{GEN}{gsubst}{GEN x, long v, GEN y} substitutes the object \kbd{y}
! 870: into~\kbd{x} for the variable number~\kbd{v}.
! 871:
! 872: \fun{int}{gdivise}{GEN x, GEN y} returns 1 (true) if \kbd{y} divides~\kbd{x},
! 873: 0~otherwise.
! 874:
! 875: \fun{GEN}{gbezout}{GEN x, GEN y, GEN *u, GEN *v} creates the GCD of \kbd{x}
! 876: and~\kbd{y}, and puts (the adresses of) objects $u$ and~$v$ such that
! 877: $u\kbd{x}+v\kbd{y}=\gcd(\kbd{x},\kbd{y})$ into \kbd{*u} and~\kbd{*v}.
! 878: \vfill\eject
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to usersch5.tex CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / pari / doc