Lines Matching defs:digits
131 /* ensure there are always at least MP_PREC digits extra on top */
148 /* zero excess digits */
155 /* shift left a certain amount of digits */
167 /* grow to fit the new digits */
191 /* zero the lower digits */
196 /* trim unused digits
198 * This is used to ensure that leading zero digits are
201 * are no more leading digits
270 /* shift by as many digits in the bit count */
321 /* make sure there are at least two digits */
356 /* get number of digits and add that */
373 /* compare based on # of non-zero digits */
388 /* compare based on digits */
431 /* set the digits to zero */
434 /* set the used to zero, allocated digits to the default precision
502 /* pad size so there are always extra digits */
516 /* zero the digits */
541 * them. "x" will point to the input with the most digits
593 * if A or B has more digits add those in
611 /* clear digits above oldused */
666 /* now copy higher words if any, e.g. if A has more digits than B */
678 /* clear digits above used (since we may not have grown result above) */
725 /* shift right a certain amount of digits */
741 * the window is b-digits long and digits from
753 /* remove excess digits */
882 /* zero digits above the last digit of the modulus */
929 /* shift by as many digits in the bit count */
976 * the case where digits are removed from 'x' in
978 * case that y has fewer than three digits, etc..
1245 /* zero excess digits */
1627 /* if more than half of the digits are -1 we're sold */
1730 /* now zero any excess digits on the destination
1804 * (we're talking 1000s of digits here...).
2069 * let n represent half of the number of digits in
2083 * Note that a multiplication of half the digits requires
2104 /* min # of digits */
2133 /* now shift the digits */
2142 /* we copy the digits directly instead of using higher level functions
2143 * since we also need to shift the digits
2167 * upper words x1/y1 must have a known number of digits
2240 * digits of output so if say only a half-product is required
2262 /* number of output digits to produce */
2310 /* clear unused digits [that existed in the old copy of c] */
2322 * have less than MP_WARRAY digits and the number of
2323 * digits won't affect carry propagation
2337 /* multiplies |a| * |b| and only computes upto digs digits of result
2339 * many digits of output are created.
2360 /* compute the digits of the product directly */
2366 /* limit ourselves to making digs digits of output */
2376 /* an alias for the digits of b */
2437 * output digits *above* digs. See the comments for fast_s_mul_digs
2441 * only the higher digits were needed. This essentially halves the work.
2460 /* number of output digits to produce */
2505 /* clear unused digits [that existed in the old copy of c] */
2518 /* multiplies |a| * |b| and does not compute the lower digs digits
2549 /* alias to the address of where the digits will be stored */
2947 /* min # of digits */
3063 /* number of output digits to produce */
3123 /* clear unused digits [that existed in the old copy of c] */
3352 /* if digidx == -1 we are out of digits */
3460 /* must be at least two digits */
3605 /* first we have to get the digits of the input into
3615 /* alias for the digits of x*/
3618 /* copy the digits of a into W[0..a->used-1] */
3629 /* now we proceed to zero successive digits
3650 * column since the Montgomery reduction requires digits of the
3661 /* alias for the digits of the modulus */
3679 * significant digits we zeroed].
3714 /* zero oldused digits, if the input a was larger than
3715 * m->used+1 we'll have to clear the digits
3780 /* alias for digits of the modulus */
3783 /* alias for the digits of x [the input] */
3814 * significant digits of x are all zero
3816 * right by n.used digits and the
3872 /* m = digits in modulus */
3875 /* ensure that "x" has at least 2m digits */
3886 /* aliases for digits */
4178 /* if digidx == -1 we are out of digits so break */
4568 /* old number of used digits in c */
4589 /* now handle rest of the digits */
4682 /* handle rest of the digits */
4690 /* zero excess digits */
4714 /* scan lower digits until non-zero */
4937 /* fetch out all of the digits */
4984 /* we have to reverse our digits later... but not the - sign!! */
5010 /* reverse the digits of the string. In this case _s points
5618 int digits;
5624 mp_init_size(rnd, digits = howmany(bits, DIGIT_BIT));
5625 for (i = 0 ; i < digits ; i++) {
Indexes created Wed Oct 01 07:09:59 GMT 2025