## src/share/classes/java/math/BigInteger.java

 ``` ``````2034 if (modVal.equals(ONE)) 2035 return ONE; 2036 2037 MutableBigInteger a = new MutableBigInteger(modVal); 2038 MutableBigInteger b = new MutableBigInteger(m); 2039 2040 MutableBigInteger result = a.mutableModInverse(b); 2041 return result.toBigInteger(1); 2042 } 2043 2044 // Shift Operations 2045 2046 /** 2047 * Returns a BigInteger whose value is {@code (this << n)}. 2048 * The shift distance, {@code n}, may be negative, in which case 2049 * this method performs a right shift. 2050 * (Computes floor(this * 2n).) 2051 * 2052 * @param n shift distance, in bits. 2053 * @return {@code this << n} 2054 * @see #shiftRight 2055 */ 2056 public BigInteger shiftLeft(int n) { 2057 if (signum == 0) 2058 return ZERO; 2059 if (n==0) 2060 return this; 2061 if (n<0) 2062 return shiftRight(-n); 2063 2064 int nInts = n >>> 5; 2065 int nBits = n & 0x1f; 2066 int magLen = mag.length; 2067 int newMag[] = null; 2068 2069 if (nBits == 0) { 2070 newMag = new int[magLen + nInts]; 2071 for (int i=0; i>> nBits2; 2077 if (highBits != 0) { 2078 newMag = new int[magLen + nInts + 1]; 2079 newMag[i++] = highBits; 2080 } else { 2081 newMag = new int[magLen + nInts]; 2082 } 2083 int j=0; 2084 while (j < magLen-1) 2085 newMag[i++] = mag[j++] << nBits | mag[j] >>> nBits2; 2086 newMag[i] = mag[j] << nBits; 2087 } 2088 2089 return new BigInteger(newMag, signum); 2090 } 2091 2092 /** 2093 * Returns a BigInteger whose value is {@code (this >> n)}. Sign 2094 * extension is performed. The shift distance, {@code n}, may be 2095 * negative, in which case this method performs a left shift. 2096 * (Computes floor(this / 2n).) 2097 * 2098 * @param n shift distance, in bits. 2099 * @return {@code this >> n} 2100 * @see #shiftLeft 2101 */ 2102 public BigInteger shiftRight(int n) { 2103 if (n==0) 2104 return this; 2105 if (n<0) 2106 return shiftLeft(-n); 2107 2108 int nInts = n >>> 5; 2109 int nBits = n & 0x1f; 2110 int magLen = mag.length; 2111 int newMag[] = null; 2112 2113 // Special case: entire contents shifted off the end 2114 if (nInts >= magLen) 2115 return (signum >= 0 ? ZERO : negConst[1]); 2116 2117 if (nBits == 0) { 2118 int newMagLen = magLen - nInts; 2119 newMag = new int[newMagLen]; 2120 for (int i=0; i>> nBits; 2125 if (highBits != 0) { 2126 newMag = new int[magLen - nInts]; ``` ``` ``````2034 if (modVal.equals(ONE)) 2035 return ONE; 2036 2037 MutableBigInteger a = new MutableBigInteger(modVal); 2038 MutableBigInteger b = new MutableBigInteger(m); 2039 2040 MutableBigInteger result = a.mutableModInverse(b); 2041 return result.toBigInteger(1); 2042 } 2043 2044 // Shift Operations 2045 2046 /** 2047 * Returns a BigInteger whose value is {@code (this << n)}. 2048 * The shift distance, {@code n}, may be negative, in which case 2049 * this method performs a right shift. 2050 * (Computes floor(this * 2n).) 2051 * 2052 * @param n shift distance, in bits. 2053 * @return {@code this << n} 2054 * @throws ArithmeticException if the shift distance is {@code 2055 * Integer.MIN_VALUE}. 2056 * @see #shiftRight 2057 */ 2058 public BigInteger shiftLeft(int n) { 2059 if (signum == 0) 2060 return ZERO; 2061 if (n==0) 2062 return this; 2063 if (n<0) { 2064 if (n == Integer.MIN_VALUE) { 2065 throw new ArithmeticException("Shift distance of Integer.MIN_VALUE not supported."); 2066 } else { 2067 return shiftRight(-n); 2068 } 2069 } 2070 2071 int nInts = n >>> 5; 2072 int nBits = n & 0x1f; 2073 int magLen = mag.length; 2074 int newMag[] = null; 2075 2076 if (nBits == 0) { 2077 newMag = new int[magLen + nInts]; 2078 for (int i=0; i>> nBits2; 2084 if (highBits != 0) { 2085 newMag = new int[magLen + nInts + 1]; 2086 newMag[i++] = highBits; 2087 } else { 2088 newMag = new int[magLen + nInts]; 2089 } 2090 int j=0; 2091 while (j < magLen-1) 2092 newMag[i++] = mag[j++] << nBits | mag[j] >>> nBits2; 2093 newMag[i] = mag[j] << nBits; 2094 } 2095 2096 return new BigInteger(newMag, signum); 2097 } 2098 2099 /** 2100 * Returns a BigInteger whose value is {@code (this >> n)}. Sign 2101 * extension is performed. The shift distance, {@code n}, may be 2102 * negative, in which case this method performs a left shift. 2103 * (Computes floor(this / 2n).) 2104 * 2105 * @param n shift distance, in bits. 2106 * @return {@code this >> n} 2107 * @throws ArithmeticException if the shift distance is {@code 2108 * Integer.MIN_VALUE}. 2109 * @see #shiftLeft 2110 */ 2111 public BigInteger shiftRight(int n) { 2112 if (n==0) 2113 return this; 2114 if (n<0) { 2115 if (n == Integer.MIN_VALUE) { 2116 throw new ArithmeticException("Shift distance of Integer.MIN_VALUE not supported."); 2117 } else { 2118 return shiftLeft(-n); 2119 } 2120 } 2121 2122 int nInts = n >>> 5; 2123 int nBits = n & 0x1f; 2124 int magLen = mag.length; 2125 int newMag[] = null; 2126 2127 // Special case: entire contents shifted off the end 2128 if (nInts >= magLen) 2129 return (signum >= 0 ? ZERO : negConst[1]); 2130 2131 if (nBits == 0) { 2132 int newMagLen = magLen - nInts; 2133 newMag = new int[newMagLen]; 2134 for (int i=0; i>> nBits; 2139 if (highBits != 0) { 2140 newMag = new int[magLen - nInts]; ```