dorkbox.util.MathUtil Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of Utilities Show documentation
Show all versions of Utilities Show documentation
Utilities for use within Java projects
/*
* Copyright 2010 dorkbox, llc
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package dorkbox.util;
public
class MathUtil {
/**
* Checks to see if the string is an integer
*
* @return true if it's an integer, false otherwise
*/
public static
boolean isInteger(final String string) {
return isNumber(string, 10);
}
/**
* Checks to see if the string is a long
*
* @return true if it's a long, false otherwise
*/
public static
boolean isLong(final String string) {
return isNumber(string, 19);
}
/**
* Checks to see if the character is a number
*
* @return true if it's a number, false otherwise
*/
public static
boolean isNumber(final char character) {
// way faster than Character.isDigit()
return character >= '0' && character <= '9';
}
/**
* Checks to see if the string is a number
*
* @return true if it's a number, false otherwise
*/
public static
boolean isNumber(final String string, long sizeLimit) {
if (string == null) {
return false;
}
if (sizeLimit <= 0) {
return false;
}
int length = string.length();
if (length == 0) {
return false;
}
int i = 0;
if (string.charAt(0) == '-') {
if (length == 1) {
return false;
}
i = 1;
}
if (length - i > sizeLimit) {
return false;
}
for (; i < length; i++) {
char c = string.charAt(i);
// way faster than Character.isDigit()
if (c < '0' || c > '9') {
return false;
}
}
return true;
}
/**
* Gets the number of digits represented by the specified number
*
* @param number the number to check, negative numbers are also acceptable but the sign is not counted
*
* @return the number of digits of the number, from 1-19.
*/
public static
int numberOfDigits(long number) {
// have to make it always positive for the following checks to pass.
if (number < 0L) {
number = -number;
}
// Guessing 4 digit numbers will be more probable.
// They are set in the first branch.
if (number < 10000L) { // from 1 to 4
if (number < 100L) { // 1 or 2
if (number < 10L) {
return 1;
}
else {
return 2;
}
}
else { // 3 or 4
if (number < 1000L) {
return 3;
}
else {
return 4;
}
}
}
else { // from 5 to 20 (albeit longs can't have more than 18 or 19)
if (number < 1000000000000L) { // from 5 to 12
if (number < 100000000L) { // from 5 to 8
if (number < 1000000L) { // 5 or 6
if (number < 100000L) {
return 5;
}
else {
return 6;
}
}
else { // 7 u 8
if (number < 10000000L) {
return 7;
}
else {
return 8;
}
}
}
else { // from 9 to 12
if (number < 10000000000L) { // 9 or 10
if (number < 1000000000L) {
return 9;
}
else {
return 10;
}
}
else { // 11 or 12
if (number < 100000000000L) {
return 11;
}
else {
return 12;
}
}
}
}
else { // from 13 to ... (18 or 20)
if (number < 10000000000000000L) { // from 13 to 16
if (number < 100000000000000L) { // 13 or 14
if (number < 10000000000000L) {
return 13;
}
else {
return 14;
}
}
else { // 15 or 16
if (number < 1000000000000000L) {
return 15;
}
else {
return 16;
}
}
}
else { // from 17 to ... 20?
if (number < 1000000000000000000L) { // 17 or 18
if (number < 100000000000000000L) {
return 17;
}
else {
return 18;
}
}
else { // 19? Can it be?
// 10000000000000000000L isn't a valid long.
return 19;
}
}
}
}
}
/**
* Removes any characters from the end that are not a number
*
* @param text the input text that may, or may not, contain a mix of numbers and letters
* @return the value as an integer
*/
public static
int stripTrailingNonDigits(final String text) {
if (text == null || text.isEmpty()) {
return 0;
}
int numberIndex = 0;
int length = text.length();
while (numberIndex < length && Character.isDigit(text.charAt(numberIndex))) {
numberIndex++;
}
String substring = text.substring(0, numberIndex);
try {
return Integer.parseInt(substring);
} catch (Exception ignored) {
}
return 0;
}
public static
boolean isEven(int value) {
return (value & 1) == 0;
}
/**
* Returns the next power of two. Returns the specified value if the value is already a power of two.
*/
public static
int nextPowerOfTwo(int value) {
return 1 << (32 - Integer.numberOfLeadingZeros(value - 1));
}
public static
boolean isPowerOfTwo(int value) {
return value != 0 && (value & value - 1) == 0;
}
public static
boolean intersectRect(double x1, double y1, double w1, double h1, double x2, double y2, double w2, double h2) {
return intersectRange(x1, x1 + w1, x2, x2 + w2) && intersectRange(y1, y1 + h1, y2, y2 + h2);
}
public static
boolean intersectRange(double ax1, double ax2, double bx1, double bx2) {
return Math.max(ax1, bx1) <= Math.min(ax2, bx2);
}
/**
* Clamps a value to min/max values, where it cannot exceed either.
*
* @return the new value, clamped
*/
public static
int clamp(int value, int min, int max) {
return Math.max(min, Math.min(max, value));
}
/**
* Clamps a value to min/max values, where it cannot exceed either.
*
* @return the new value, clamped
*/
public static
long clamp(long value, long min, long max) {
return Math.max(min, Math.min(max, value));
}
/**
* Clamps a value to min/max values, where it cannot exceed either.
*
* @return the new value, clamped
*/
public static
float clamp(float value, float min, float max) {
return Math.max(min, Math.min(max, value));
}
/**
* Clamps a value to min/max values, where it cannot exceed either.
*
* @return the new value, clamped
*/
public static
double clamp(double value, double min, double max) {
return Math.max(min, Math.min(max, value));
}
}