/** * Returns a new {@code BigDecimal} instance where the decimal point has * been moved {@code n} places to the right. If {@code n < 0} then the * decimal point is moved {@code -n} places to the left. * * <p>The result is obtained by changing its scale. If the scale of the result * becomes negative, then its precision is increased such that the scale is * zero. * * <p>Note, that {@code movePointRight(0)} returns a result which is * mathematically equivalent, but which has scale >= 0. */ public BigDecimal movePointRight(int n) { return movePoint(scale - (long)n); }
/** * Returns a new {@code BigDecimal} instance where the decimal point has * been moved {@code n} places to the left. If {@code n < 0} then the * decimal point is moved {@code -n} places to the right. * * <p>The result is obtained by changing its scale. If the scale of the result * becomes negative, then its precision is increased such that the scale is * zero. * * <p>Note, that {@code movePointLeft(0)} returns a result which is * mathematically equivalent, but which has {@code scale >= 0}. */ public BigDecimal movePointLeft(int n) { return movePoint(scale + (long)n); }
/** * Returns a new {@code BigDecimal} instance where the decimal point has * been moved {@code n} places to the right. If {@code n < 0} then the * decimal point is moved {@code -n} places to the left. * * <p>The result is obtained by changing its scale. If the scale of the result * becomes negative, then its precision is increased such that the scale is * zero. * * <p>Note, that {@code movePointRight(0)} returns a result which is * mathematically equivalent, but which has scale >= 0. */ public BigDecimal movePointRight(int n) { return movePoint(scale - (long)n); }
/** * Returns a new {@code BigDecimal} instance where the decimal point has * been moved {@code n} places to the left. If {@code n < 0} then the * decimal point is moved {@code -n} places to the right. * * <p>The result is obtained by changing its scale. If the scale of the result * becomes negative, then its precision is increased such that the scale is * zero. * * <p>Note, that {@code movePointLeft(0)} returns a result which is * mathematically equivalent, but which has {@code scale >= 0}. */ public BigDecimal movePointLeft(int n) { return movePoint(scale + (long)n); }
/** * Returns a new {@code BigDecimal} instance where the decimal point has * been moved {@code n} places to the left. If {@code n < 0} then the * decimal point is moved {@code -n} places to the right. * * <p>The result is obtained by changing its scale. If the scale of the result * becomes negative, then its precision is increased such that the scale is * zero. * * <p>Note, that {@code movePointLeft(0)} returns a result which is * mathematically equivalent, but which has {@code scale >= 0}. */ public BigDecimal movePointLeft(int n) { return movePoint(scale + (long)n); }
/** * Returns a new {@code BigDecimal} instance where the decimal point has * been moved {@code n} places to the right. If {@code n < 0} then the * decimal point is moved {@code -n} places to the left. * * <p>The result is obtained by changing its scale. If the scale of the result * becomes negative, then its precision is increased such that the scale is * zero. * * <p>Note, that {@code movePointRight(0)} returns a result which is * mathematically equivalent, but which has scale >= 0. */ public BigDecimal movePointRight(int n) { return movePoint(scale - (long)n); }
/** * Returns a new {@code BigDecimal} instance where the decimal point has * been moved {@code n} places to the left. If {@code n < 0} then the * decimal point is moved {@code -n} places to the right. * * <p>The result is obtained by changing its scale. If the scale of the result * becomes negative, then its precision is increased such that the scale is * zero. * * <p>Note, that {@code movePointLeft(0)} returns a result which is * mathematically equivalent, but which has {@code scale >= 0}. */ public BigDecimal movePointLeft(int n) { return movePoint(scale + (long)n); }
/** * Returns a new {@code BigDecimal} instance where the decimal point has * been moved {@code n} places to the right. If {@code n < 0} then the * decimal point is moved {@code -n} places to the left. * * <p>The result is obtained by changing its scale. If the scale of the result * becomes negative, then its precision is increased such that the scale is * zero. * * <p>Note, that {@code movePointRight(0)} returns a result which is * mathematically equivalent, but which has scale >= 0. */ public BigDecimal movePointRight(int n) { return movePoint(scale - (long)n); }
/** * Returns a new {@code BigDecimal} instance where the decimal point has * been moved {@code n} places to the left. If {@code n < 0} then the * decimal point is moved {@code -n} places to the right. * * <p>The result is obtained by changing its scale. If the scale of the result * becomes negative, then its precision is increased such that the scale is * zero. * * <p>Note, that {@code movePointLeft(0)} returns a result which is * mathematically equivalent, but which has {@code scale >= 0}. */ public BigDecimal movePointLeft(int n) { return movePoint(scale + (long)n); }
/** * Returns a new {@code BigDecimal} instance where the decimal point has * been moved {@code n} places to the left. If {@code n < 0} then the * decimal point is moved {@code -n} places to the right. * * <p>The result is obtained by changing its scale. If the scale of the result * becomes negative, then its precision is increased such that the scale is * zero. * * <p>Note, that {@code movePointLeft(0)} returns a result which is * mathematically equivalent, but which has {@code scale >= 0}. */ public BigDecimal movePointLeft(int n) { return movePoint(scale + (long)n); }
/** * Returns a new {@code BigDecimal} instance where the decimal point has * been moved {@code n} places to the right. If {@code n < 0} then the * decimal point is moved {@code -n} places to the left. * * <p>The result is obtained by changing its scale. If the scale of the result * becomes negative, then its precision is increased such that the scale is * zero. * * <p>Note, that {@code movePointRight(0)} returns a result which is * mathematically equivalent, but which has scale >= 0. */ public BigDecimal movePointRight(int n) { return movePoint(scale - (long)n); }
/** * Returns a new {@code BigDecimal} instance where the decimal point has * been moved {@code n} places to the left. If {@code n < 0} then the * decimal point is moved {@code -n} places to the right. * * <p>The result is obtained by changing its scale. If the scale of the result * becomes negative, then its precision is increased such that the scale is * zero. * * <p>Note, that {@code movePointLeft(0)} returns a result which is * mathematically equivalent, but which has {@code scale >= 0}. */ public BigDecimal movePointLeft(int n) { return movePoint(scale + (long)n); }
/** * Returns a new {@code BigDecimal} instance where the decimal point has * been moved {@code n} places to the right. If {@code n < 0} then the * decimal point is moved {@code -n} places to the left. * * <p>The result is obtained by changing its scale. If the scale of the result * becomes negative, then its precision is increased such that the scale is * zero. * * <p>Note, that {@code movePointRight(0)} returns a result which is * mathematically equivalent, but which has scale >= 0. */ public BigDecimal movePointRight(int n) { return movePoint(scale - (long)n); }
/** * Returns a new {@code BigDecimal} instance where the decimal point has * been moved {@code n} places to the right. If {@code n < 0} then the * decimal point is moved {@code -n} places to the left. * * <p>The result is obtained by changing its scale. If the scale of the result * becomes negative, then its precision is increased such that the scale is * zero. * * <p>Note, that {@code movePointRight(0)} returns a result which is * mathematically equivalent, but which has scale >= 0. */ public BigDecimal movePointRight(int n) { return movePoint(scale - (long)n); }