| /src/external/lgpl3/gmp/dist/mpz/ |
| invert.c | 1 /* mpz_invert (inv, x, n). Find multiplicative inverse of X in Z(N).
2 If X has an inverse, return non-zero and store inverse in INVERSE,
3 otherwise, return 0 and put garbage in INVERSE.
36 mpz_invert (mpz_ptr inverse, mpz_srcptr x, mpz_srcptr n)
52 /* If no inverse existed, return with an indication of that. */
59 /* Make sure we return a positive inverse. */
63 mpz_sub (inverse, tmp, n);
65 mpz_add (inverse, tmp, n)
[all...] |
| /src/external/lgpl3/gmp/dist/mpn/generic/ |
| dive_1.c | 80 mp_limb_t c, h, l, ls, s, s_next, inverse, dummy; local
97 binvert_limb (inverse, divisor);
114 l = (l * inverse) & GMP_NUMB_MASK;
123 l = (l * inverse) & GMP_NUMB_MASK;
130 l = (s * inverse) & GMP_NUMB_MASK;
142 l = (l * inverse) & GMP_NUMB_MASK;
|
| mode1o.c | 76 In terms of efficiency, this function is similar to a mul-by-inverse
86 have r<d too, for the following reasons. Let q=l*inverse be the quotient
117 mp_limb_t s, h, l, inverse, dummy, dmul, ret; local
146 binvert_limb (inverse, d);
154 l = (l * inverse) & GMP_NUMB_MASK;
179 l = (l * inverse) & GMP_NUMB_MASK;
207 mp_limb_t s, x, y, inverse, dummy, dmul, c1, c2;
214 binvert_limb (inverse, d);
227 y = (y * inverse) & GMP_NUMB_MASK;
|
| /src/external/lgpl3/gmp/dist/mpn/sparc64/ |
| dive_1.c | 55 inverse.
59 mul-by-inverse. At size==2 the inverse is about 260 cycles total
67 mp_limb_t inverse, s, s_next, c, l, ls, q; local
103 binvert_limb (inverse, divisor);
119 q = l * inverse;
131 q = l * inverse;
146 q = l * inverse;
158 q = l * inverse;
|
| mode1o.c | 72 possibility would be to take two limbs at a time, with a 128 bit inverse,
83 mp_limb_t s, l, q, h, inverse; local
91 /* udivx is faster than 10 or 12 mulx's for one limb via an inverse */
110 binvert_limb (inverse, d);
120 q = l * inverse;
144 q = l * inverse;
164 q = l * inverse;
188 q = l * inverse;
|
| /src/external/lgpl3/gmp/dist/mpn/alpha/ |
| dive_1.c | 51 23 13 7 mulq q = y * inverse
61 mp_limb_t inverse, lshift_mask, s, sr, s_next, c, h, x, y, q, dummy; local
81 binvert_limb (inverse, divisor);
101 q = y * inverse;
112 q = y * inverse;
|
| mode1o.asm | 48 C 23 13 7 mulq q = y * inverse
64 C - The subq y=x-climb can be done without waiting for the inverse.
66 C - The mulq y*inverse is replicated after the final subq for the inverse,
78 C calculating an inverse, the latter taking about 130 cycles on ev4 or 70 on
97 ` ldbu r20, 0(r21) C table[idx], inverse 8 bits
100 extbl r20, r21, r20 C table[idx], inverse 8 bits
112 subq r20, r7, r20 C 2*i-i*i*d, inverse 16 bits
119 subq r20, r7, r20 C 2*i-i*i*d, inverse 32 bits
127 subq r20, r7, r20 C inv = 2*i-i*i*d, inverse 64 bit
[all...] |
| /src/external/gpl2/texinfo/dist/info/ |
| display.h | 36 int inverse; /* Non-zero means this line is inverse. */ member in struct:__anon9519
|
| display.c | 62 display[i]->inverse = 0;
303 if ((entry && entry->inverse)
309 entry->inverse = 0;
335 || (entry->inverse))
351 /* Lines showing node text are not in inverse. Only modelines
353 entry->inverse = 0;
425 /* This display line must both be in inverse, and have the same
427 if ((!display[line_index]->inverse) ||
435 display[line_index]->inverse = 1;
493 the_display[i]->inverse = 0
[all...] |
| /src/external/lgpl3/gmp/dist/mpn/ia64/ |
| dive_1.asm | 50 C The critical path during initialization is for computing the inverse of the
54 C Possible improvement: Merge more of the feed-in code into the inverse
122 }{.mmi; ld1 r3 = [r3] C M0 inverse, 8 bits
129 }{.mmi; setf.sig f7 = r3 C M2 inverse, 8 bits
136 C f7 inverse, being calculated
137 C f8 -1, will be -inverse
167 .Ln1: xmpy.l f12 = f10, f7 C q = ulimb * inverse
171 xmpy.l f8 = f7, f8 C -inverse = inverse * -1
172 xmpy.l f12 = f11, f7 C q = ulimb * inverse
[all...] |
| mode1o.asm | 56 C q = low(l * inverse)
59 C but we can work the src[i]-c into an xma by calculating si=src[i]*inverse
62 C q = low(c * inverse + si)
82 C The first limb uses q = (src[0]-c) * inverse shown in the first style.
83 C This lets us get the first q as soon as the inverse is ready, without
84 C going through si=s*inverse. Basically at the start we have c and can use
85 C it while waiting for the inverse, whereas for the second and subsequent
86 C limbs it's the other way around, ie. we have the inverse and are waiting
97 C inverse, so this is begun first and optimized. Apart from that, ar.lc is
103 C Inverse Calculation
[all...] |
| /src/external/lgpl3/gmp/dist/mpn/powerpc32/ |
| mode1o.asm | 49 C For PIC, the inverse is established arithmetically since it measures about
57 C The loop allows an early-out on mullw for the inverse, and on mulhwu for
58 C the divisor. So the fastest is for instance divisor==1 (inverse==-1), and
60 C divisor==0xDEADBEEF (inverse==0x904B300F). These establish the stated
81 xor r4, r4, r7 C inverse, 4 bits
86 sub r4, r4, r7 C inverse, 8 bits
90 lbzx r4, r4,r7 C inverse, 8 bits
96 sub r4, r4, r7 C inverse, 16 bits
101 sub r4, r4, r7 C inverse, 32 bits
104 mullw r7, r7, r4 C q = l * inverse
[all...] |
| /src/crypto/external/apache2/openssl/dist/crypto/idea/ |
| i_skey.c | 20 static IDEA_INT inverse(unsigned int xin);
69 *(tp++) = inverse(fp[0]);
72 *(tp++) = inverse(fp[3]);
91 static IDEA_INT inverse(unsigned int xin) function
|
| /src/crypto/external/bsd/openssl/dist/crypto/idea/ |
| i_skey.c | 21 static IDEA_INT inverse(unsigned int xin);
70 *(tp++) = inverse(fp[0]);
73 *(tp++) = inverse(fp[3]);
92 static IDEA_INT inverse(unsigned int xin) function
|
| /src/crypto/external/bsd/openssl.old/dist/crypto/idea/ |
| i_skey.c | 14 static IDEA_INT inverse(unsigned int xin);
63 *(tp++) = inverse(fp[0]);
66 *(tp++) = inverse(fp[3]);
85 static IDEA_INT inverse(unsigned int xin) function
|
| /src/external/gpl3/gdb.old/dist/gdb/ |
| mingw-hdep.c | 290 int fgcolor, bgcolor, bright, inverse; local
318 /* Inverse video. */
320 inverse = 1;
322 inverse = 0;
325 if (inverse)
|
| /src/external/lgpl3/gmp/dist/mpn/x86/pentium4/sse2/ |
| dive_1.asm | 44 C Using divl for size==1 seems a touch quicker than mul-by-inverse. The mul
155 C pmuludq q = s*inverse 8
173 C mm5 inverse
190 pmuludq %mm5, %mm2 C s*inverse
209 pmuludq %mm5, %mm2 C s*inverse
|
| bdiv_q_1.asm | 54 C mp_limb_t inverse, int shift)
89 C pmuludq q = s*inverse 8
107 C mm5 inverse
124 pmuludq %mm5, %mm2 C s*inverse
143 pmuludq %mm5, %mm2 C s*inverse
|
| mode1o.asm | 129 C pmuludq q = s*inverse 8
146 C mm6 inverse
158 pmuludq %mm6, %mm2 C s*inverse
|
| /src/external/gpl3/gdb/dist/gdb/ |
| mingw-hdep.c | 301 int fgcolor, bgcolor, bright, inverse; local
329 /* Inverse video. */
331 inverse = 1;
333 inverse = 0;
336 if (inverse)
|
| /src/bin/ed/ |
| cbc.c | 108 if (des_cipher(buf, buf, 0L, (inverse ? -1 : 1))) \
390 int inverse = 0; /* 0 to encrypt, 1 to decrypt */ local
430 int inverse = 1; /* 0 to encrypt, 1 to decrypt */ local
|
| /src/external/lgpl3/gmp/dist/mpn/x86_64/ |
| mode1o.asm | 140 C r9 inverse
146 imul %r9, %rax C q = l * inverse
162 imul %r9, %rax C q = l * inverse
|
| /src/external/lgpl3/gmp/dist/ |
| gen-psqr.c | 110 mpz_t pp_inverted; /* invert_limb style inverse */
125 mpz_t inverse; /* 1/divisor mod 2^mod_bits */ member in struct:factor_t
414 mpz_init (factor[i].inverse);
415 mpz_invert_ui_2exp (factor[i].inverse,
519 mpz_out_str (stdout, 16, factor[i].inverse);
|
| /src/external/lgpl3/gmp/dist/mpn/arm/v6/ |
| mode1o.asm | 72 rsb r4, r4, r12, asl #1 C r4 = inverse
79 rsb r5, r4, #0 C r5 = -inverse
|
| /src/libexec/ld.elf_so/arch/powerpc/ |
| rtld_start.S | 93 * inverse. a / n = ((a * inv(n)) >> 32)
97 lis %r11,0x15555556@h # load multiplicative inverse of 12
|
