src/java.base/share/classes/java/lang/StrictMath.java
changeset 57923 3da1848cc39b
parent 57867 36f5e20be69a
child 58679 9c3209ff7550
equal deleted inserted replaced
57919:339af8e17cb3 57923:3da1848cc39b
   835     }
   835     }
   836 
   836 
   837     /**
   837     /**
   838      * Returns the argument incremented by one,
   838      * Returns the argument incremented by one,
   839      * throwing an exception if the result overflows an {@code int}.
   839      * throwing an exception if the result overflows an {@code int}.
       
   840      * The overflow only occurs for {@linkplain Integer#MAX_VALUE the maximum value}.
   840      *
   841      *
   841      * @param a the value to increment
   842      * @param a the value to increment
   842      * @return the result
   843      * @return the result
   843      * @throws ArithmeticException if the result overflows an int
   844      * @throws ArithmeticException if the result overflows an int
   844      * @see Math#incrementExact(int)
   845      * @see Math#incrementExact(int)
   849     }
   850     }
   850 
   851 
   851     /**
   852     /**
   852      * Returns the argument incremented by one,
   853      * Returns the argument incremented by one,
   853      * throwing an exception if the result overflows a {@code long}.
   854      * throwing an exception if the result overflows a {@code long}.
       
   855      * The overflow only occurs for {@linkplain Long#MAX_VALUE the maximum value}.
   854      *
   856      *
   855      * @param a the value to increment
   857      * @param a the value to increment
   856      * @return the result
   858      * @return the result
   857      * @throws ArithmeticException if the result overflows a long
   859      * @throws ArithmeticException if the result overflows a long
   858      * @see Math#incrementExact(long)
   860      * @see Math#incrementExact(long)
   863     }
   865     }
   864 
   866 
   865     /**
   867     /**
   866      * Returns the argument decremented by one,
   868      * Returns the argument decremented by one,
   867      * throwing an exception if the result overflows an {@code int}.
   869      * throwing an exception if the result overflows an {@code int}.
       
   870      * The overflow only occurs for {@linkplain Integer#MIN_VALUE the minimum value}.
   868      *
   871      *
   869      * @param a the value to decrement
   872      * @param a the value to decrement
   870      * @return the result
   873      * @return the result
   871      * @throws ArithmeticException if the result overflows an int
   874      * @throws ArithmeticException if the result overflows an int
   872      * @see Math#decrementExact(int)
   875      * @see Math#decrementExact(int)
   877     }
   880     }
   878 
   881 
   879     /**
   882     /**
   880      * Returns the argument decremented by one,
   883      * Returns the argument decremented by one,
   881      * throwing an exception if the result overflows a {@code long}.
   884      * throwing an exception if the result overflows a {@code long}.
       
   885      * The overflow only occurs for {@linkplain Long#MIN_VALUE the minimum value}.
   882      *
   886      *
   883      * @param a the value to decrement
   887      * @param a the value to decrement
   884      * @return the result
   888      * @return the result
   885      * @throws ArithmeticException if the result overflows a long
   889      * @throws ArithmeticException if the result overflows a long
   886      * @see Math#decrementExact(long)
   890      * @see Math#decrementExact(long)
   891     }
   895     }
   892 
   896 
   893     /**
   897     /**
   894      * Returns the negation of the argument,
   898      * Returns the negation of the argument,
   895      * throwing an exception if the result overflows an {@code int}.
   899      * throwing an exception if the result overflows an {@code int}.
       
   900      * The overflow only occurs for {@linkplain Integer#MIN_VALUE the minimum value}.
   896      *
   901      *
   897      * @param a the value to negate
   902      * @param a the value to negate
   898      * @return the result
   903      * @return the result
   899      * @throws ArithmeticException if the result overflows an int
   904      * @throws ArithmeticException if the result overflows an int
   900      * @see Math#negateExact(int)
   905      * @see Math#negateExact(int)
   905     }
   910     }
   906 
   911 
   907     /**
   912     /**
   908      * Returns the negation of the argument,
   913      * Returns the negation of the argument,
   909      * throwing an exception if the result overflows a {@code long}.
   914      * throwing an exception if the result overflows a {@code long}.
       
   915      * The overflow only occurs for {@linkplain Long#MIN_VALUE the minimum value}.
   910      *
   916      *
   911      * @param a the value to negate
   917      * @param a the value to negate
   912      * @return the result
   918      * @return the result
   913      * @throws ArithmeticException if the result overflows a long
   919      * @throws ArithmeticException if the result overflows a long
   914      * @see Math#negateExact(long)
   920      * @see Math#negateExact(long)