< prev index next >

## src/java.base/share/classes/java/lang/Math.java

 ``` ``````1062 * throwing an exception if the value overflows an {@code int}. 1063 * 1064 * @param value the long value 1065 * @return the argument as an int 1066 * @throws ArithmeticException if the {@code argument} overflows an int 1067 * @since 1.8 1068 */ 1069 public static int toIntExact(long value) { 1070 if ((int)value != value) { 1071 throw new ArithmeticException("integer overflow"); 1072 } 1073 return (int)value; 1074 } 1075 1076 /** 1077 * Returns the exact mathematical product of the arguments. 1078 * 1079 * @param x the first value 1080 * @param y the second value 1081 * @return the result 1082 */ 1083 public static long multiplyFull(int x, int y) { 1084 return (long)x * (long)y; 1085 } 1086 1087 /** 1088 * Returns as a {@code long} the most significant 64 bits of the 128-bit 1089 * product of two 64-bit factors. 1090 * 1091 * @param x the first value 1092 * @param y the second value 1093 * @return the result 1094 */ 1095 public static long multiplyHigh(long x, long y) { 1096 if (x < 0 || y < 0) { 1097 // Use technique from section 8-2 of Henry S. Warren, Jr., 1098 // Hacker's Delight (2nd ed.) (Addison Wesley, 2013), 173-174. 1099 long x1 = x >> 32; 1100 long x2 = x & 0xFFFFFFFFL; 1101 long y1 = y >> 32; 1102 long y2 = y & 0xFFFFFFFFL; 1103 long z2 = x2 * y2; 1104 long t = x1 * y2 + (z2 >>> 32); 1105 long z1 = t & 0xFFFFFFFFL; 1106 long z0 = t >> 32; 1107 z1 += x2 * y1; 1108 return x1 * y1 + z0 + (z1 >> 32); 1109 } else { 1110 // Use Karatsuba technique with two base 2^32 digits. 1111 long x1 = x >>> 32; 1112 long y1 = y >>> 32; 1113 long x2 = x & 0xFFFFFFFFL; ``` ``` ``````1062 * throwing an exception if the value overflows an {@code int}. 1063 * 1064 * @param value the long value 1065 * @return the argument as an int 1066 * @throws ArithmeticException if the {@code argument} overflows an int 1067 * @since 1.8 1068 */ 1069 public static int toIntExact(long value) { 1070 if ((int)value != value) { 1071 throw new ArithmeticException("integer overflow"); 1072 } 1073 return (int)value; 1074 } 1075 1076 /** 1077 * Returns the exact mathematical product of the arguments. 1078 * 1079 * @param x the first value 1080 * @param y the second value 1081 * @return the result 1082 * @since 9 1083 */ 1084 public static long multiplyFull(int x, int y) { 1085 return (long)x * (long)y; 1086 } 1087 1088 /** 1089 * Returns as a {@code long} the most significant 64 bits of the 128-bit 1090 * product of two 64-bit factors. 1091 * 1092 * @param x the first value 1093 * @param y the second value 1094 * @return the result 1095 * @since 9 1096 */ 1097 public static long multiplyHigh(long x, long y) { 1098 if (x < 0 || y < 0) { 1099 // Use technique from section 8-2 of Henry S. Warren, Jr., 1100 // Hacker's Delight (2nd ed.) (Addison Wesley, 2013), 173-174. 1101 long x1 = x >> 32; 1102 long x2 = x & 0xFFFFFFFFL; 1103 long y1 = y >> 32; 1104 long y2 = y & 0xFFFFFFFFL; 1105 long z2 = x2 * y2; 1106 long t = x1 * y2 + (z2 >>> 32); 1107 long z1 = t & 0xFFFFFFFFL; 1108 long z0 = t >> 32; 1109 z1 += x2 * y1; 1110 return x1 * y1 + z0 + (z1 >> 32); 1111 } else { 1112 // Use Karatsuba technique with two base 2^32 digits. 1113 long x1 = x >>> 32; 1114 long y1 = y >>> 32; 1115 long x2 = x & 0xFFFFFFFFL; ```